#include <iostream>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <climits>

namespace me
{
    template <typename T, typename Container = std::vector<T>>
    class stack
    {
    public:
        void push(const T& val) { _data.push_back(val); }
        void pop() { _data.pop_back(); }
        T& top() { return _data.back(); }
        size_t size() const { return _data.size(); }
        bool empty() const { return _data.empty(); }
    private:
        Container _data;
    };

    template <typename T, typename Container = std::list<T>>
    class queue
    {
    public:
        void push(const T& val) { _data.push_back(val); }
        void pop() { _data.pop_front(); }
        T& front() { return _data.front(); }
        T& back() { return _data.back(); }
        size_t size() const { return _data.size(); }
        bool empty() const { return _data.empty(); }
    private:
        Container _data;
    };
}

// 双队列实现栈
class MyStack {
public:
    MyStack() {
        
    }
    
    void push(int x) {
        _q.push(x);
    }
    
    int pop() {
        // 单队列实现栈，出栈时，将队列除最后一个元素外都重新插入到队尾
        int num = _q.size() - 1;
        while(num--) {
            _q.push(_q.front());
            _q.pop();
        }

        // 记录并删除队头数据
        int top = _q.front();
        _q.pop();

        // 返回
        return top;
    }
    
    int top() {
        return _q.back();
    }
    
    bool empty() {
        return _q.empty();
    }
private:
    std::queue<int> _q;
};

// 单队列实现栈
class MyStack1 
{
public:
    void push(int x) 
    {
        _q1.push(x);
    }
    
    int pop() 
    {
        if(empty()) return INT_MAX; 

        // 将q1中n个元素的前n-1个插入到q2队列中
        while(_q1.size() > 1) {
            std::cout << "转移：" << _q1.front() << std::endl;
            _q2.push(_q1.front());
            _q1.pop();
        }

        // 删除q1队列队头元素，并记录
        int top = _q1.front();
        _q1.pop();

        // 交换q1和q2，保持q1为主队列
        std::swap(_q1, _q2);

        // 返回队头元素
        return top;
    }
    
    int top() 
    {
        return _q1.back();
    }
    
    bool empty() 
    {
        return _q1.empty();
    }
private:
    std::queue<int> _q1; // 主队列，用来存储数据
    std::queue<int> _q2; // 辅助队列
};


class MyQueue {
public:
    void push(int x) 
    {
        _push_stack.push(x);
    }
    
    int pop() 
    {
        if(_pop_stack.empty()) {
            while(_push_stack.size()) {
                _pop_stack.push(_push_stack.top());
                _push_stack.pop();
            }
        }
        int ret = _pop_stack.top();
        _pop_stack.pop();
        return ret;
    }
    
    int peek() 
    {
        if(_pop_stack.empty()) {
            while(_push_stack.size()) {
                _pop_stack.push(_push_stack.top());
                _push_stack.pop();
            }
        }
        int ret = _pop_stack.top();
        return ret;
    }
    
    bool empty() 
    {
        return _push_stack.empty() && _pop_stack.empty();
    }
private:
    std::stack<int> _push_stack;
    std::stack<int> _pop_stack;
};


class A
{
private:
    int a;
};

class B : public A
{

};

int main()
{
    static int a = 0;
    return 0;
}